Swift 入门教程 - 变量、基础类型及格式化输出

发表于   |     |   阅读次数

千里之行，始于足下。

常量和变量

在现实生活中，我们会拿容器来存放东西，比如拿杯子装水，拿盘子装菜，那么对应到编程的世界里，我们需要的则是常量和变量。

在 Swift 中，你可以使用 let 关键字声明一个常量。当你声明一个常量的时候，代表着你给它赋初始值之后，你不可以再修改它的值。例如在程序中，一般 id 是唯一且不可改变的：

1
2
3
let id = 23333
// 赋值之后再修改 id 的值，编译器会报错
id = 1024

修改常量报错

如果你代码中存储的值不会改变，一定要用 let 关键字把它声明为常量。原则：起初，把所有要存储的值都定义为常量，当需要修改值时再把它改为 var 关键字修饰。

当你需要声明一个在赋值完初始值之后，还可能修改变量值的时候，可以使用 var 关键字声明一个变量，例如在程序中，用户的昵称是可以修改的：

1
2
3
var nickName = "Swift"
// 赋值之后，还可以修改 nickName 变量的值
nickName = "Objective-C"

在 Swift 中，你使用的常量或者变量需要在使用之前声明它，如果使用未声明的变量，编译器会报错：

1
2
// 因为使用的 age 变量并未声明，所以编译器会报错
age = 10

使用未声明的变量

命名规则

在 Swift 中，采用驼峰命名法则给变量和类命名。变量用小写字母开头，后面的单词依次首字母大写。例如：userName、userAge等；而类的名字则是大写字母开头，后面的单词依次首字母大写。

例如：SeniorStudent等。在 Swift 中不要使用下划线命名，如：user_name 这种格式。虽然使用这种格式编译器不会报错，但这会影响程序的代码统一性，也给项目维护增大了难度。

类型推断

从上面的代码可以看出，我们声明常量或者变量的时候并没有显式的表现它们是什么类型，那么编译器又是怎么知道我们声明的变量的类型呢？答案就是 Swift 的编译器会进行类型推断(Type Annotations)。当你声明一个变量，并给予该变量初始值的时候， Swift 会根据你赋予的值来给变量正确的类型(按住 option 键，点击变量名可以看见变量的类型)。

1
2
3
4
5
6
// 通过查看变量类型，我们可以看到 identifier 为 Int， height 为 Double
![](https://user-gold-cdn.xitu.io/2019/12/16/16f0ef7509bbeba6?w=758&h=198&f=png&s=20046)
let identifier = 23333
// 等同于 let identifier: Int = 23333
var height = 1.75
// 等同于 var height: Double = 1.75

Swift 的类型推断

基础类型

整型

Int

声明 Int 类型的常量：

1
let age = 18

在 Swift 中，多数情况下你不需要指定整型的类型(如 Int32、Int64)，编译器会自动适配当前平台。也就是说：在 32 位的系统上，Int 就是 Int32；在 64 位的系统上 Int 就是 Int64。

UInt

声明 UInt 类型的常量：

1
2
// 此时不能省略类型，因为编译器总是把整型推断为 Int
let positiveNumber: UInt = 18

UInt 平台适配规则同 Int，在 32 位的系统上，UInt 就是 UInt32；在 64 位的系统上 UInt 就是 UInt64。

当声明整型类型时，尽量使用 Int 类型，它在各种情况下是适应最好的。

获取当前整型类型的范围(例如 Int32、Int64)：

1
2
3
4
5
6
7
let min32 = Int32.min
let max32 = Int32.max
// min32 = -2147483648, max32 = 2147483647
let min64 = Int64.min
let max64 = Int64.max
// min64 = -9223372036854775808, max64 = 9223372036854775807

浮点数

Float

Float：32位的单精度，有至少6位小数的精度。

1
let float32: Float = 0.01

Double

Doubel：64位的单精度，有至少15位小数的精度。

1
let float64 = 0.01

Swift 的类型推断，总是把浮点数类型推断为 Double。

字符串

在程序开发中，打交道最多的类型莫过于字符串了。你可以通过下面的方式来存储字符串的值：

1
let language = "Swift"

你也可以在 Swift 中存储多行字符串的值：

1
2
3
4
let multipleStr = """
Swift
Objective-C
"""

可对字符串应用的操作符

Swift 中，你可以对字符串应用以下 2 个操作符：

  • +：拼接字符串
  • +=：对字符串进行累加

具体示例：

1
2
3
4
5
6
7
let language = "Swift"
let welcome = "Hello"
// plusStr = HelloSwift
let plusStr = welcome + language
var languages = "Language: "
// languages = Language: Swift
languages += language

基本类型互转

浮点数转整型

1
2
3
let floatNum = 1.2
// intNum = 1
let intNum = Int(floatNum)

整型转浮点数

1
2
3
let intNum = 1
// floatNum = 1
let floatNum = Double(intNum)

需要注意的是：只有在特定情况下才会使用 Float，其它情况下都要使用 Double（官方文档推荐）。

字符串转整型、整型转字符串

字符串和数字类型的互相转换大概使我们写代码中遇到的最频繁的转换了。

  • 字符串转整型

    1
    2
    3
    4
    5
    let strNum = "2333"
    // 注意此处 intNum 为 Int? 类型，这里涉及可选类型 - optional，
    后面会将到可选类型，这里看一下即可。
    intNum = Optional(2333)
    let intNum = Int(strNum)

  • 整型转字符串

    1
    2
    3
    let intNum = 23333
    // strNum = "23333"
    let strNum = String(intNum)

格式化输出

前面声明了许多常量，那么怎样能快捷的看到常量存储的值呢，这里就用到 print() 函数了。

你可以简单的只打印一个常量或者变量：

1
2
let strNum = "Swift"
print(strNum)

在程序比较简单的时候，上面这种打印方式还可以。但在程序越来越复杂时，打印的东西会错综复杂。这时，你就需要使用格式化输出了。

1
2
// strNum = Swift
print("strNum = \(strNum)")

格式化输出格式： "xxx\(变量、常量的名字)" xxx会原样输出，\()里面放置你声明变量。

在格式化输出时，后面可以放置多个变量。

1
2
3
4
let min32 = Int32.min
let max32 = Int32.max
// min32 = -2147483648, max32 = 2147483647
print("min32 = \(min32), max32 = \(max32)")

总结

建议以上的代码都在 Playground 里面多敲几遍，看懂并不代表会了。

  • 使用常量或者变量之前要先声明
  • let 关键字声明的常量不可修改；var 关键字声明的变量值可以修改